From e3cc39cb9813de101d35611e761ccc1571a3267c Mon Sep 17 00:00:00 2001 From: Tristan Van Berkom Date: Wed, 13 Oct 2010 22:26:08 +0900 Subject: [PATCH] Removed all traces of GtkWrapBox from GTK+. --- docs/reference/gtk/gtk-docs.sgml | 1 - gtk/Makefile.am | 4 +- gtk/gtk.h | 1 - gtk/gtk.symbols | 27 - gtk/gtkenums.h | 54 - gtk/gtkwrapbox.c | 2636 ------------------------------ gtk/gtkwrapbox.h | 102 -- tests/Makefile.am | 8 +- tests/testwrapbox.c | 496 ------ 9 files changed, 2 insertions(+), 3327 deletions(-) delete mode 100644 gtk/gtkwrapbox.c delete mode 100644 gtk/gtkwrapbox.h delete mode 100644 tests/testwrapbox.c diff --git a/docs/reference/gtk/gtk-docs.sgml b/docs/reference/gtk/gtk-docs.sgml index 9007dd1d99..f5497d93bf 100644 --- a/docs/reference/gtk/gtk-docs.sgml +++ b/docs/reference/gtk/gtk-docs.sgml @@ -305,7 +305,6 @@ that is, GUI components such as GtkButton or GtkTextView. - diff --git a/gtk/Makefile.am b/gtk/Makefile.am index 848d20ff89..8ee97015dc 100644 --- a/gtk/Makefile.am +++ b/gtk/Makefile.am @@ -332,8 +332,7 @@ gtk_public_h_sources = \ gtkvscrollbar.h \ gtkvseparator.h \ gtkwidget.h \ - gtkwindow.h \ - gtkwrapbox.h + gtkwindow.h if OS_UNIX gtk_unix_print_public_h_sources = \ @@ -615,7 +614,6 @@ gtk_base_c_sources = \ gtkwidget.c \ gtkwindow-decorate.c \ gtkwindow.c \ - gtkwrapbox.c \ $(gtk_clipboard_dnd_c_sources) gtk_c_sources = $(gtk_base_c_sources) diff --git a/gtk/gtk.h b/gtk/gtk.h index f970cb35d0..1527512341 100644 --- a/gtk/gtk.h +++ b/gtk/gtk.h @@ -215,7 +215,6 @@ #include #include #include -#include #undef __GTK_H_INSIDE__ diff --git a/gtk/gtk.symbols b/gtk/gtk.symbols index 010f32cf4f..08d13d187b 100644 --- a/gtk/gtk.symbols +++ b/gtk/gtk.symbols @@ -4475,33 +4475,6 @@ gtk_window_unstick #endif -#if IN_HEADER(__GTK_WRAP_BOX_H__) -#if IN_FILE(__GTK_WRAP_BOX_C__) -gtk_wrap_allocation_mode_get_type -gtk_wrap_box_get_allocation_mode -gtk_wrap_box_get_horizontal_spacing -gtk_wrap_box_get_minimum_line_children -gtk_wrap_box_get_natural_line_children -gtk_wrap_box_get_horizontal_spreading -gtk_wrap_box_get_vertical_spreading -gtk_wrap_box_get_type G_GNUC_CONST -gtk_wrap_box_get_vertical_spacing -gtk_wrap_box_insert_child -gtk_wrap_box_new -gtk_wrap_box_packing_get_type -gtk_wrap_box_reorder_child -gtk_wrap_box_set_allocation_mode -gtk_wrap_box_set_horizontal_spacing -gtk_wrap_box_set_minimum_line_children -gtk_wrap_box_set_natural_line_children -gtk_wrap_box_set_horizontal_spreading -gtk_wrap_box_set_vertical_spreading -gtk_wrap_box_set_vertical_spacing -gtk_wrap_box_spreading_get_type -#endif -#endif - - #if IN_HEADER(__GTK_WIN32_EMBED_WIDGET_H__) #if IN_FILE(__GTK_WIN32_EMBED_WIDGET_C__) #ifdef G_OS_WIN32 diff --git a/gtk/gtkenums.h b/gtk/gtkenums.h index 98cd0a5257..515881e9e4 100644 --- a/gtk/gtkenums.h +++ b/gtk/gtkenums.h @@ -541,60 +541,6 @@ typedef enum GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT } GtkSizeRequestMode; - -/** - * GtkWrapAllocationMode: - * @GTK_WRAP_ALLOCATE_FREE: Items wrap freely in the box's orientation - * @GTK_WRAP_ALLOCATE_ALIGNED: Items are aligned into rows and columns - * @GTK_WRAP_ALLOCATE_HOMOGENEOUS: Items are all allocated the same size - * - * Describes how an #GtkWrapBox positions its children. - */ -typedef enum { - GTK_WRAP_ALLOCATE_FREE = 0, - GTK_WRAP_ALLOCATE_ALIGNED, - GTK_WRAP_ALLOCATE_HOMOGENEOUS -} GtkWrapAllocationMode; - -/** - * GtkWrapBoxSpreading: - * @GTK_WRAP_BOX_SPREAD_START: Children are allocated no more than their natural size - * in the given orientation and any extra space is left trailing at - * the end of each row/column. - * @GTK_WRAP_BOX_SPREAD_END: Children are allocated no more than their natural size - * in the given orientation and any extra space skipped at the beginning - * of each row/column. - * @GTK_WRAP_BOX_SPREAD_EVEN: Children are allocated no more than their natural size - * in the given orientation and any extra space is evenly distributed - * as empty space between children. - * @GTK_WRAP_BOX_SPREAD_EXPAND: Extra space is given to children which asked to expand in the given - * orientation (or columns/rows which contain children who asked to expand). - * If no children asked to expand; extra space is distributed evenly. - * - * Describes how a #GtkWrapBox deals with extra space in a given orientation when allocating children. - */ -typedef enum { - GTK_WRAP_BOX_SPREAD_START = 0, - GTK_WRAP_BOX_SPREAD_END, - GTK_WRAP_BOX_SPREAD_EVEN, - GTK_WRAP_BOX_SPREAD_EXPAND -} GtkWrapBoxSpreading; - -/** - * GtkWrapBoxPacking: - * @GTK_WRAP_BOX_H_EXPAND: Whether the child expands horizontally. - * @GTK_WRAP_BOX_V_EXPAND: Whether the child expands vertically. - * - * Specifies how widgets will expand vertically and - * horizontally when placed inside a #GtkWrapBox. - */ -typedef enum -{ - GTK_WRAP_BOX_H_EXPAND = 1 << 0, - GTK_WRAP_BOX_V_EXPAND = 1 << 1 -} GtkWrapBoxPacking; - - G_END_DECLS #endif /* __GTK_ENUMS_H__ */ diff --git a/gtk/gtkwrapbox.c b/gtk/gtkwrapbox.c deleted file mode 100644 index 4bcf69f75b..0000000000 --- a/gtk/gtkwrapbox.c +++ /dev/null @@ -1,2636 +0,0 @@ -/* gtkwrapbox.c - * Copyright (C) 2007-2010 Openismus GmbH - * - * Authors: - * Tristan Van Berkom - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - */ - - -/** - * SECTION:gtkwrapbox - * @Short_Description: A container that wraps its children - * @Title: GtkWrapBox - * - * #GtkWrapBox positions child widgets in sequence according to its - * orientation. For instance, with the horizontal orientation, the widgets - * will be arranged from left to right, starting a new row under the - * previous row when necessary. Reducing the width in this case will - * require more rows, so a larger height will be requested. - * - * Likewise, with the vertical orientation, the widgets will be arranged - * from top to bottom, starting a new column to the right when necessary. - * Reducing the height will require more columns, so a larger width will be - * requested. - * - * Unlike a GtkTable, the child widgets do not need to align in a grid. - */ - -#include "config.h" -#include "gtksizerequest.h" -#include "gtkorientable.h" -#include "gtkwrapbox.h" -#include "gtkprivate.h" -#include "gtkintl.h" -#include "gtktypeutils.h" - - -typedef struct _GtkWrapBoxChild GtkWrapBoxChild; - -enum { - PROP_0, - PROP_ORIENTATION, - PROP_ALLOCATION_MODE, - PROP_HORIZONTAL_SPREADING, - PROP_VERTICAL_SPREADING, - PROP_HORIZONTAL_SPACING, - PROP_VERTICAL_SPACING, - PROP_MINIMUM_LINE_CHILDREN, - PROP_NATURAL_LINE_CHILDREN -}; - -enum -{ - CHILD_PROP_0, - CHILD_PROP_PACKING -}; - -struct _GtkWrapBoxPrivate -{ - GtkOrientation orientation; - GtkWrapAllocationMode mode; - GtkWrapBoxSpreading horizontal_spreading; - GtkWrapBoxSpreading vertical_spreading; - - guint16 vertical_spacing; - guint16 horizontal_spacing; - - guint16 minimum_line_children; - guint16 natural_line_children; - - GList *children; -}; - -struct _GtkWrapBoxChild -{ - GtkWidget *widget; - - GtkWrapBoxPacking packing; -}; - -/* GObjectClass */ -static void gtk_wrap_box_get_property (GObject *object, - guint prop_id, - GValue *value, - GParamSpec *pspec); -static void gtk_wrap_box_set_property (GObject *object, - guint prop_id, - const GValue *value, - GParamSpec *pspec); - -/* GtkWidgetClass */ -static void gtk_wrap_box_size_allocate (GtkWidget *widget, - GtkAllocation *allocation); - -/* GtkContainerClass */ -static void gtk_wrap_box_add (GtkContainer *container, - GtkWidget *widget); -static void gtk_wrap_box_remove (GtkContainer *container, - GtkWidget *widget); -static void gtk_wrap_box_forall (GtkContainer *container, - gboolean include_internals, - GtkCallback callback, - gpointer callback_data); -static void gtk_wrap_box_set_child_property (GtkContainer *container, - GtkWidget *child, - guint property_id, - const GValue *value, - GParamSpec *pspec); -static void gtk_wrap_box_get_child_property (GtkContainer *container, - GtkWidget *child, - guint property_id, - GValue *value, - GParamSpec *pspec); -static GType gtk_wrap_box_child_type (GtkContainer *container); - - -/* GtkWidget */ -static GtkSizeRequestMode gtk_wrap_box_get_request_mode (GtkWidget *widget); -static void gtk_wrap_box_get_preferred_width (GtkWidget *widget, - gint *minimum_size, - gint *natural_size); -static void gtk_wrap_box_get_preferred_height (GtkWidget *widget, - gint *minimum_size, - gint *natural_size); -static void gtk_wrap_box_get_preferred_height_for_width (GtkWidget *box, - gint width, - gint *minimum_height, - gint *natural_height); -static void gtk_wrap_box_get_preferred_width_for_height (GtkWidget *box, - gint width, - gint *minimum_height, - gint *natural_height); - - -G_DEFINE_TYPE_WITH_CODE (GtkWrapBox, gtk_wrap_box, GTK_TYPE_CONTAINER, - G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL)) - - -#define ORIENTATION_SPREADING(box) \ - (((GtkWrapBox *)(box))->priv->orientation == GTK_ORIENTATION_HORIZONTAL ? \ - ((GtkWrapBox *)(box))->priv->horizontal_spreading : \ - ((GtkWrapBox *)(box))->priv->vertical_spreading) - -#define OPPOSING_ORIENTATION_SPREADING(box) \ - (((GtkWrapBox *)(box))->priv->orientation == GTK_ORIENTATION_HORIZONTAL ? \ - ((GtkWrapBox *)(box))->priv->vertical_spreading : \ - ((GtkWrapBox *)(box))->priv->horizontal_spreading) - - - -static void -gtk_wrap_box_class_init (GtkWrapBoxClass *class) -{ - GObjectClass *gobject_class = G_OBJECT_CLASS (class); - GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class); - GtkContainerClass *container_class = GTK_CONTAINER_CLASS (class); - - gobject_class->get_property = gtk_wrap_box_get_property; - gobject_class->set_property = gtk_wrap_box_set_property; - - widget_class->size_allocate = gtk_wrap_box_size_allocate; - widget_class->get_request_mode = gtk_wrap_box_get_request_mode; - widget_class->get_preferred_width = gtk_wrap_box_get_preferred_width; - widget_class->get_preferred_height = gtk_wrap_box_get_preferred_height; - widget_class->get_preferred_height_for_width = gtk_wrap_box_get_preferred_height_for_width; - widget_class->get_preferred_width_for_height = gtk_wrap_box_get_preferred_width_for_height; - - container_class->add = gtk_wrap_box_add; - container_class->remove = gtk_wrap_box_remove; - container_class->forall = gtk_wrap_box_forall; - container_class->child_type = gtk_wrap_box_child_type; - container_class->set_child_property = gtk_wrap_box_set_child_property; - container_class->get_child_property = gtk_wrap_box_get_child_property; - gtk_container_class_handle_border_width (container_class); - - /* GObjectClass properties */ - g_object_class_override_property (gobject_class, PROP_ORIENTATION, "orientation"); - - /** - * GtkWrapBox:allocation-mode: - * - * The #GtkWrapAllocationMode to use. - */ - g_object_class_install_property (gobject_class, - PROP_ALLOCATION_MODE, - g_param_spec_enum ("allocation-mode", - P_("Allocation Mode"), - P_("The allocation mode to use"), - GTK_TYPE_WRAP_ALLOCATION_MODE, - GTK_WRAP_ALLOCATE_FREE, - GTK_PARAM_READWRITE)); - - /** - * GtkWrapBox:horizontal-spreading: - * - * The #GtkWrapBoxSpreading to used to define what is done with extra - * space in a given orientation. - */ - g_object_class_install_property (gobject_class, - PROP_HORIZONTAL_SPREADING, - g_param_spec_enum ("horizontal-spreading", - P_("Horizontal Spreading"), - P_("The spreading mode to use horizontally"), - GTK_TYPE_WRAP_BOX_SPREADING, - GTK_WRAP_BOX_SPREAD_START, - GTK_PARAM_READWRITE)); - - /** - * GtkWrapBox:vertical-spreading: - * - * The #GtkWrapBoxSpreading to used to define what is done with extra - * space in a given orientation. - */ - g_object_class_install_property (gobject_class, - PROP_VERTICAL_SPREADING, - g_param_spec_enum ("vertical-spreading", - P_("Vertical Spreading"), - P_("The spreading mode to use vertically"), - GTK_TYPE_WRAP_BOX_SPREADING, - GTK_WRAP_BOX_SPREAD_START, - GTK_PARAM_READWRITE)); - - - /** - * GtkWrapBox:minimum-line-children: - * - * The minimum number of children to allocate consecutively in the given orientation. - * - * Setting the minimum children per line ensures - * that a reasonably small height will be requested - * for the overall minimum width of the box. - * - */ - g_object_class_install_property (gobject_class, - PROP_MINIMUM_LINE_CHILDREN, - g_param_spec_uint ("minimum-line-children", - P_("Minimum Line Children"), - P_("The minimum number of children to allocate " - "consecutively in the given orientation."), - 0, - 65535, - 0, - GTK_PARAM_READWRITE)); - - /** - * GtkWrapBox:natural-line-children: - * - * The maximum amount of children to request space for consecutively in the given orientation. - * - */ - g_object_class_install_property (gobject_class, - PROP_NATURAL_LINE_CHILDREN, - g_param_spec_uint ("natural-line-children", - P_("Natural Line Children"), - P_("The maximum amount of children to request space for " - "consecutively in the given orientation."), - 0, - 65535, - 0, - GTK_PARAM_READWRITE)); - - /** - * GtkWrapBox:vertical-spacing: - * - * The amount of vertical space between two children. - * - */ - g_object_class_install_property (gobject_class, - PROP_VERTICAL_SPACING, - g_param_spec_uint ("vertical-spacing", - P_("Vertical spacing"), - P_("The amount of vertical space between two children"), - 0, - 65535, - 0, - GTK_PARAM_READWRITE)); - - /** - * GtkWrapBox:horizontal-spacing: - * - * The amount of horizontal space between two children. - * - */ - g_object_class_install_property (gobject_class, - PROP_HORIZONTAL_SPACING, - g_param_spec_uint ("horizontal-spacing", - P_("Horizontal spacing"), - P_("The amount of horizontal space between two children"), - 0, - 65535, - 0, - GTK_PARAM_READWRITE)); - - /* GtkContainerClass child properties */ - - /** - * GtkWrapBox:packing: - * - * The #GtkWrapBoxPacking options to specify how to pack a child into the box. - */ - gtk_container_class_install_child_property (container_class, - CHILD_PROP_PACKING, - g_param_spec_flags - ("packing", - P_("Packing"), - P_("The packing options to use for this child"), - GTK_TYPE_WRAP_BOX_PACKING, 0, - GTK_PARAM_READWRITE)); - - g_type_class_add_private (class, sizeof (GtkWrapBoxPrivate)); -} - -static void -gtk_wrap_box_init (GtkWrapBox *box) -{ - GtkWrapBoxPrivate *priv; - - box->priv = priv = - G_TYPE_INSTANCE_GET_PRIVATE (box, GTK_TYPE_WRAP_BOX, GtkWrapBoxPrivate); - - priv->orientation = GTK_ORIENTATION_HORIZONTAL; - priv->mode = GTK_WRAP_ALLOCATE_FREE; - priv->horizontal_spreading = GTK_WRAP_BOX_SPREAD_START; - priv->vertical_spreading = GTK_WRAP_BOX_SPREAD_START; - priv->horizontal_spacing = 0; - priv->vertical_spacing = 0; - priv->children = NULL; - - gtk_widget_set_has_window (GTK_WIDGET (box), FALSE); -} - -/***************************************************** - * GObectClass * - *****************************************************/ -static void -gtk_wrap_box_get_property (GObject *object, - guint prop_id, - GValue *value, - GParamSpec *pspec) -{ - GtkWrapBox *box = GTK_WRAP_BOX (object); - GtkWrapBoxPrivate *priv = box->priv; - - switch (prop_id) - { - case PROP_ORIENTATION: - g_value_set_boolean (value, priv->orientation); - break; - case PROP_ALLOCATION_MODE: - g_value_set_enum (value, priv->mode); - break; - case PROP_HORIZONTAL_SPREADING: - g_value_set_enum (value, priv->horizontal_spreading); - break; - case PROP_VERTICAL_SPREADING: - g_value_set_enum (value, priv->vertical_spreading); - break; - case PROP_HORIZONTAL_SPACING: - g_value_set_uint (value, priv->horizontal_spacing); - break; - case PROP_VERTICAL_SPACING: - g_value_set_uint (value, priv->vertical_spacing); - break; - case PROP_MINIMUM_LINE_CHILDREN: - g_value_set_uint (value, priv->minimum_line_children); - break; - case PROP_NATURAL_LINE_CHILDREN: - g_value_set_uint (value, priv->natural_line_children); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } -} - -static void -gtk_wrap_box_set_property (GObject *object, - guint prop_id, - const GValue *value, - GParamSpec *pspec) -{ - GtkWrapBox *box = GTK_WRAP_BOX (object); - GtkWrapBoxPrivate *priv = box->priv; - - switch (prop_id) - { - case PROP_ORIENTATION: - priv->orientation = g_value_get_enum (value); - - /* Re-box the children in the new orientation */ - gtk_widget_queue_resize (GTK_WIDGET (box)); - break; - case PROP_ALLOCATION_MODE: - gtk_wrap_box_set_allocation_mode (box, g_value_get_enum (value)); - break; - case PROP_HORIZONTAL_SPREADING: - gtk_wrap_box_set_horizontal_spreading (box, g_value_get_enum (value)); - break; - case PROP_VERTICAL_SPREADING: - gtk_wrap_box_set_vertical_spreading (box, g_value_get_enum (value)); - break; - case PROP_HORIZONTAL_SPACING: - gtk_wrap_box_set_horizontal_spacing (box, g_value_get_uint (value)); - break; - case PROP_VERTICAL_SPACING: - gtk_wrap_box_set_vertical_spacing (box, g_value_get_uint (value)); - break; - case PROP_MINIMUM_LINE_CHILDREN: - gtk_wrap_box_set_minimum_line_children (box, g_value_get_uint (value)); - break; - case PROP_NATURAL_LINE_CHILDREN: - gtk_wrap_box_set_natural_line_children (box, g_value_get_uint (value)); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } -} - -/***************************************************** - * GtkWidgetClass * - *****************************************************/ - -static gint -get_visible_children (GtkWrapBox *box) -{ - GtkWrapBoxPrivate *priv = box->priv; - GList *list; - gint i = 0; - - for (list = priv->children; list; list = list->next) - { - GtkWrapBoxChild *child = list->data; - - if (!gtk_widget_get_visible (child->widget)) - continue; - - i++; - } - - return i; -} - -static gint -get_visible_expand_children (GtkWrapBox *box, - GtkOrientation orientation, - GList *cursor, - gint n_visible) -{ - GList *list; - gint i, expand_children = 0; - - for (i = 0, list = cursor; (n_visible > 0 ? i < n_visible : TRUE) && list; list = list->next) - { - GtkWrapBoxChild *child = list->data; - - if (!gtk_widget_get_visible (child->widget)) - continue; - - if ((orientation == GTK_ORIENTATION_HORIZONTAL && (child->packing & GTK_WRAP_BOX_H_EXPAND) != 0) || - (orientation == GTK_ORIENTATION_VERTICAL && (child->packing & GTK_WRAP_BOX_V_EXPAND) != 0)) - expand_children++; - - i++; - } - - return expand_children; -} - -/* Used in columned modes where all items share at least their - * equal widths or heights - */ -static void -get_average_item_size (GtkWrapBox *box, - GtkOrientation orientation, - gint *min_size, - gint *nat_size) -{ - GtkWrapBoxPrivate *priv = box->priv; - GList *list; - gint max_min_size = 0; - gint max_nat_size = 0; - - for (list = priv->children; list; list = list->next) - { - GtkWrapBoxChild *child = list->data; - gint child_min, child_nat; - - if (!gtk_widget_get_visible (child->widget)) - continue; - - if (orientation == GTK_ORIENTATION_HORIZONTAL) - gtk_widget_get_preferred_width (child->widget, &child_min, &child_nat); - else - gtk_widget_get_preferred_height (child->widget, &child_min, &child_nat); - - max_min_size = MAX (max_min_size, child_min); - max_nat_size = MAX (max_nat_size, child_nat); - } - - if (min_size) - *min_size = max_min_size; - - if (nat_size) - *nat_size = max_nat_size; -} - - -/* Gets the largest minimum/natural size for a given size - * (used to get the largest item heights for a fixed item width and the opposite) */ -static void -get_largest_size_for_opposing_orientation (GtkWrapBox *box, - GtkOrientation orientation, - gint item_size, - gint *min_item_size, - gint *nat_item_size) -{ - GtkWrapBoxPrivate *priv = box->priv; - GList *list; - gint max_min_size = 0; - gint max_nat_size = 0; - - for (list = priv->children; list; list = list->next) - { - GtkWrapBoxChild *child = list->data; - gint child_min, child_nat; - - if (!gtk_widget_get_visible (child->widget)) - continue; - - if (orientation == GTK_ORIENTATION_HORIZONTAL) - gtk_widget_get_preferred_height_for_width (child->widget, - item_size, - &child_min, &child_nat); - else - gtk_widget_get_preferred_width_for_height (child->widget, - item_size, - &child_min, &child_nat); - - max_min_size = MAX (max_min_size, child_min); - max_nat_size = MAX (max_nat_size, child_nat); - } - - if (min_item_size) - *min_item_size = max_min_size; - - if (nat_item_size) - *nat_item_size = max_nat_size; -} - - -/* Gets the largest minimum/natural size on a single line for a given size - * (used to get the largest line heights for a fixed item width and the opposite - * while itterating over a list of children, note the new index is returned) */ -static GList * -get_largest_size_for_line_in_opposing_orientation (GtkWrapBox *box, - GtkOrientation orientation, - GList *cursor, - gint line_length, - GtkRequestedSize *item_sizes, - gint extra_pixels, - gint *min_item_size, - gint *nat_item_size) -{ - GList *list; - gint max_min_size = 0; - gint max_nat_size = 0; - gint i; - - for (list = cursor, i = 0; list && i < line_length; list = list->next) - { - GtkWrapBoxChild *child = list->data; - gint child_min, child_nat, this_item_size; - - if (!gtk_widget_get_visible (child->widget)) - continue; - - /* Distribute the extra pixels to the first children in the line - * (could be fancier and spread them out more evenly) */ - this_item_size = item_sizes[i].minimum_size; - if (extra_pixels > 0 && ORIENTATION_SPREADING (box) == GTK_WRAP_BOX_SPREAD_EXPAND) - { - this_item_size++; - extra_pixels--; - } - - if (orientation == GTK_ORIENTATION_HORIZONTAL) - gtk_widget_get_preferred_height_for_width (child->widget, - this_item_size, - &child_min, &child_nat); - else - gtk_widget_get_preferred_width_for_height (child->widget, - this_item_size, - &child_min, &child_nat); - - max_min_size = MAX (max_min_size, child_min); - max_nat_size = MAX (max_nat_size, child_nat); - - i++; - } - - if (min_item_size) - *min_item_size = max_min_size; - - if (nat_item_size) - *nat_item_size = max_nat_size; - - /* Return next item in the list */ - return list; -} - - -/* Gets the largest minimum/natural size on a single line for a given allocated line size - * (used to get the largest line heights for a width in pixels and the opposite - * while itterating over a list of children, note the new index is returned) */ -static GList * -get_largest_size_for_free_line_in_opposing_orientation (GtkWrapBox *box, - GtkOrientation orientation, - GList *cursor, - gint min_items, - gint avail_size, - gint *min_item_size, - gint *nat_item_size, - gint *extra_pixels, - GArray **ret_array) -{ - GtkWrapBoxPrivate *priv = box->priv; - GtkRequestedSize *sizes; - GList *list; - GArray *array; - gint max_min_size = 0; - gint max_nat_size = 0; - gint i, size = avail_size; - gint line_length, spacing; - gint expand_children = 0; - gint expand_per_child; - gint expand_remainder; - - if (orientation == GTK_ORIENTATION_HORIZONTAL) - spacing = priv->horizontal_spacing; - else - spacing = priv->vertical_spacing; - - /* First determine the length of this line in items (how many items fit) */ - for (i = 0, list = cursor; size > 0 && list; list = list->next) - { - GtkWrapBoxChild *child = list->data; - gint child_size; - - if (!gtk_widget_get_visible (child->widget)) - continue; - - if (orientation == GTK_ORIENTATION_HORIZONTAL) - gtk_widget_get_preferred_width (child->widget, NULL, &child_size); - else - gtk_widget_get_preferred_height (child->widget, NULL, &child_size); - - if (i > 0) - child_size += spacing; - - if (size - child_size >= 0) - size -= child_size; - else - break; - - i++; - } - - line_length = MAX (min_items, i); - size = avail_size; - - /* Collect the sizes of the items on this line */ - array = g_array_new (0, TRUE, sizeof (GtkRequestedSize)); - - for (i = 0, list = cursor; i < line_length && list; list = list->next) - { - GtkWrapBoxChild *child = list->data; - GtkRequestedSize requested; - - if (!gtk_widget_get_visible (child->widget)) - continue; - - requested.data = child; - if (orientation == GTK_ORIENTATION_HORIZONTAL) - gtk_widget_get_preferred_width (child->widget, - &requested.minimum_size, - &requested.natural_size); - else - gtk_widget_get_preferred_height (child->widget, - &requested.minimum_size, - &requested.natural_size); - - if (i > 0) - size -= spacing; - - size -= requested.minimum_size; - - g_array_append_val (array, requested); - - i++; - } - - sizes = (GtkRequestedSize *)array->data; - size = gtk_distribute_natural_allocation (size, array->len, sizes); - - if (extra_pixels) - *extra_pixels = size; - - /* Cut out any expand space if we're not distributing any */ - if (ORIENTATION_SPREADING (box) != GTK_WRAP_BOX_SPREAD_EXPAND) - size = 0; - - /* Count how many children are going to expand... */ - expand_children = get_visible_expand_children (box, orientation, - cursor, line_length); - - /* If no child prefers to expand, they all get some expand space */ - if (expand_children == 0) - { - expand_per_child = size / line_length; - expand_remainder = size % line_length; - } - else - { - expand_per_child = size / expand_children; - expand_remainder = size % expand_children; - } - - /* Now add the remaining expand space and get the collective size of this line - * in the opposing orientation */ - for (i = 0, list = cursor; i < line_length && list; list = list->next) - { - GtkWrapBoxChild *child = list->data; - gint child_min, child_nat; - - if (!gtk_widget_get_visible (child->widget)) - continue; - - g_assert (child == sizes[i].data); - - if ((orientation == GTK_ORIENTATION_HORIZONTAL && (child->packing & GTK_WRAP_BOX_H_EXPAND) != 0) || - (orientation == GTK_ORIENTATION_VERTICAL && (child->packing & GTK_WRAP_BOX_V_EXPAND) != 0) || - expand_children == 0) - { - sizes[i].minimum_size += expand_per_child; - if (expand_remainder) - { - sizes[i].minimum_size++; - expand_remainder--; - } - } - - if (orientation == GTK_ORIENTATION_HORIZONTAL) - gtk_widget_get_preferred_height_for_width (child->widget, - sizes[i].minimum_size, - &child_min, &child_nat); - else - gtk_widget_get_preferred_width_for_height (child->widget, - sizes[i].minimum_size, - &child_min, &child_nat); - - max_min_size = MAX (max_min_size, child_min); - max_nat_size = MAX (max_nat_size, child_nat); - - i++; - } - - if (ret_array) - *ret_array = array; - else - g_array_free (array, TRUE); - - if (min_item_size) - *min_item_size = max_min_size; - - if (nat_item_size) - *nat_item_size = max_nat_size; - - /* Return the next item */ - return list; -} - -static void -allocate_child (GtkWrapBox *box, - GtkWrapBoxChild *child, - gint item_offset, - gint line_offset, - gint item_size, - gint line_size) -{ - GtkWrapBoxPrivate *priv = box->priv; - GtkAllocation widget_allocation; - GtkAllocation child_allocation; - - gtk_widget_get_allocation (GTK_WIDGET (box), &widget_allocation); - - if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) - { - child_allocation.x = widget_allocation.x + item_offset; - child_allocation.y = widget_allocation.y + line_offset; - child_allocation.width = item_size; - child_allocation.height = line_size; - } - else /* GTK_ORIENTATION_VERTICAL */ - { - child_allocation.x = widget_allocation.x + line_offset; - child_allocation.y = widget_allocation.y + item_offset; - child_allocation.width = line_size; - child_allocation.height = item_size; - } - - gtk_widget_size_allocate (child->widget, &child_allocation); -} - -/* fit_aligned_item_requests() helper */ -static gint -gather_aligned_item_requests (GtkWrapBox *box, - GtkOrientation orientation, - gint line_length, - gint item_spacing, - gint n_children, - GtkRequestedSize *item_sizes) -{ - GtkWrapBoxPrivate *priv = box->priv; - GList *list; - gint i; - gint extra_items, natural_line_size = 0; - - extra_items = n_children % line_length; - - for (list = priv->children, i = 0; list; list = list->next, i++) - { - GtkWrapBoxChild *child = list->data; - gint child_min, child_nat; - gint position; - - if (!gtk_widget_get_visible (child->widget)) - continue; - - if (orientation == GTK_ORIENTATION_HORIZONTAL) - gtk_widget_get_preferred_width (child->widget, - &child_min, &child_nat); - else - gtk_widget_get_preferred_height (child->widget, - &child_min, &child_nat); - - /* Get the index and push it over for the last line when spreading to the end */ - position = i % line_length; - - if (ORIENTATION_SPREADING (box) == GTK_WRAP_BOX_SPREAD_END && i >= n_children - extra_items) - position += line_length - extra_items; - - /* Round up the size of every column/row */ - item_sizes[position].minimum_size = MAX (item_sizes[position].minimum_size, child_min); - item_sizes[position].natural_size = MAX (item_sizes[position].natural_size, child_nat); - } - - for (i = 0; i < line_length; i++) - natural_line_size += item_sizes[i].natural_size; - - natural_line_size += (line_length - 1) * item_spacing; - - return natural_line_size; -} - -static GtkRequestedSize * -fit_aligned_item_requests (GtkWrapBox *box, - GtkOrientation orientation, - gint avail_size, - gint item_spacing, - gint *line_length, /* in-out */ - gint n_children) -{ - GtkRequestedSize *sizes, *try_sizes; - gint try_line_size, try_length; - - sizes = g_new0 (GtkRequestedSize, *line_length); - - /* get the sizes for the initial guess */ - try_line_size = - gather_aligned_item_requests (box, orientation, *line_length, item_spacing, n_children, sizes); - - /* Try columnizing the whole thing and adding an item to the end of the line; - * try to fit as many columns into the available size as possible */ - for (try_length = *line_length + 1; try_line_size < avail_size; try_length++) - { - try_sizes = g_new0 (GtkRequestedSize, try_length); - try_line_size = gather_aligned_item_requests (box, orientation, try_length, item_spacing, - n_children, try_sizes); - - if (try_line_size <= avail_size) - { - *line_length = try_length; - - g_free (sizes); - sizes = try_sizes; - } - else - { - /* oops, this one failed; stick to the last size that fit and then return */ - g_free (try_sizes); - break; - } - } - - return sizes; -} - - -typedef struct { - GArray *requested; - gint extra_pixels; -} AllocatedLine; - -static void -gtk_wrap_box_size_allocate (GtkWidget *widget, - GtkAllocation *allocation) -{ - GtkWrapBox *box = GTK_WRAP_BOX (widget); - GtkWrapBoxPrivate *priv = box->priv; - gint avail_size, avail_other_size, min_items, item_spacing, line_spacing; - GtkWrapBoxSpreading item_spreading; - GtkWrapBoxSpreading line_spreading; - - gtk_widget_set_allocation (widget, allocation); - - min_items = MAX (1, priv->minimum_line_children); - - if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) - { - avail_size = allocation->width; - avail_other_size = allocation->height; - item_spacing = priv->horizontal_spacing; - line_spacing = priv->vertical_spacing; - } - else /* GTK_ORIENTATION_VERTICAL */ - { - avail_size = allocation->height; - avail_other_size = allocation->width; - item_spacing = priv->vertical_spacing; - line_spacing = priv->horizontal_spacing; - } - - item_spreading = ORIENTATION_SPREADING (box); - line_spreading = OPPOSING_ORIENTATION_SPREADING (box); - - - /********************************************************* - * Deal with ALIGNED/HOMOGENEOUS modes first, start with * - * initial guesses at item/line sizes * - *********************************************************/ - if (priv->mode == GTK_WRAP_ALLOCATE_ALIGNED || - priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS) - { - GtkRequestedSize *line_sizes = NULL; - GtkRequestedSize *item_sizes = NULL; - GList *list; - gint min_item_size, nat_item_size; - gint line_length; - gint item_size = 0; - gint line_size = 0, min_fixed_line_size = 0, nat_fixed_line_size = 0; - gint line_offset, item_offset, n_children, n_lines, line_count; - gint extra_pixels, extra_per_item = 0, extra_extra = 0; - gint extra_line_pixels, extra_per_line = 0, extra_line_extra = 0; - gint i, this_line_size; - - get_average_item_size (box, priv->orientation, &min_item_size, &nat_item_size); - - /* By default wrap at the natural item width */ - line_length = avail_size / (nat_item_size + item_spacing); - - /* After the above aproximation, check if we cant fit one more on the line */ - if (line_length * item_spacing + (line_length + 1) * nat_item_size <= avail_size) - line_length++; - - /* Its possible we were allocated just less than the natural width of the - * minimum item wrap length */ - line_length = MAX (min_items, line_length); - - /* Get how many lines we'll be needing to wrap */ - n_children = get_visible_children (box); - - /* Here we just use the largest height-for-width and use that for the height - * of all lines */ - if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS) - { - n_lines = n_children / line_length; - if ((n_children % line_length) > 0) - n_lines++; - - n_lines = MAX (n_lines, 1); - - /* Now we need the real item allocation size */ - item_size = (avail_size - (line_length - 1) * item_spacing) / line_length; - - /* Cut out the expand space if we're not distributing any */ - if (item_spreading != GTK_WRAP_BOX_SPREAD_EXPAND) - item_size = MIN (item_size, nat_item_size); - - get_largest_size_for_opposing_orientation (box, priv->orientation, item_size, - &min_fixed_line_size, - &nat_fixed_line_size); - - /* resolve a fixed 'line_size' */ - line_size = (avail_other_size - (n_lines - 1) * line_spacing) / n_lines; - - if (line_spreading != GTK_WRAP_BOX_SPREAD_EXPAND) - line_size = MIN (line_size, nat_fixed_line_size); - - /* Get the real extra pixels incase of GTK_WRAP_BOX_SPREAD_START lines */ - extra_pixels = avail_size - (line_length - 1) * item_spacing - item_size * line_length; - extra_line_pixels = avail_other_size - (n_lines - 1) * line_spacing - line_size * n_lines; - } - else /* GTK_WRAP_ALLOCATE_ALIGNED */ - { - GList *list; - gboolean first_line = TRUE; - - /* Find the amount of columns that can fit aligned into the available space - * and collect their requests. - */ - item_sizes = fit_aligned_item_requests (box, priv->orientation, avail_size, - item_spacing, &line_length, n_children); - - /* Calculate the number of lines after determining the final line_length */ - n_lines = n_children / line_length; - if ((n_children % line_length) > 0) - n_lines++; - - n_lines = MAX (n_lines, 1); - line_sizes = g_new0 (GtkRequestedSize, n_lines); - - /* Get the available remaining size */ - avail_size -= (line_length - 1) * item_spacing; - for (i = 0; i < line_length; i++) - avail_size -= item_sizes[i].minimum_size; - - /* Perform a natural allocation on the columnized items and get the remaining pixels */ - extra_pixels = gtk_distribute_natural_allocation (avail_size, line_length, item_sizes); - - /* Now that we have the size of each column of items find the size of each individual - * line based on the aligned item sizes. - */ - for (i = 0, list = priv->children; list != NULL; i++) - { - - list = - get_largest_size_for_line_in_opposing_orientation (box, priv->orientation, - list, line_length, - item_sizes, extra_pixels, - &line_sizes[i].minimum_size, - &line_sizes[i].natural_size); - - - /* Its possible a line is made of completely invisible children */ - if (line_sizes[i].natural_size > 0) - { - if (first_line) - first_line = FALSE; - else - avail_other_size -= line_spacing; - - avail_other_size -= line_sizes[i].minimum_size; - - line_sizes[i].data = GINT_TO_POINTER (i); - } - } - - /* Distribute space among lines naturally */ - extra_line_pixels = gtk_distribute_natural_allocation (avail_other_size, n_lines, line_sizes); - } - - /********************************************************* - * Initial sizes of items/lines guessed at this point, * - * go on to distribute expand space if needed. * - *********************************************************/ - - /* FIXME: This portion needs to consider which columns - * and rows asked for expand space and distribute those - * accordingly for the case of ALIGNED allocation. - * - * If at least one child in a column/row asked for expand; - * we should make that row/column expand entirely. - */ - - /* Calculate expand space per item */ - if (item_spreading == GTK_WRAP_BOX_SPREAD_EVEN) - { - extra_per_item = extra_pixels / MAX (line_length -1, 1); - extra_extra = extra_pixels % MAX (line_length -1, 1); - } - else if (item_spreading == GTK_WRAP_BOX_SPREAD_EXPAND) - { - extra_per_item = extra_pixels / line_length; - extra_extra = extra_pixels % line_length; - } - - /* Calculate expand space per line */ - if (line_spreading == GTK_WRAP_BOX_SPREAD_EVEN) - { - extra_per_line = extra_line_pixels / MAX (n_lines -1, 1); - extra_line_extra = extra_line_pixels % MAX (n_lines -1, 1); - } - else if (line_spreading == GTK_WRAP_BOX_SPREAD_EXPAND) - { - extra_per_line = extra_line_pixels / n_lines; - extra_line_extra = extra_line_pixels % n_lines; - } - - /********************************************************* - * Prepare item/line initial offsets and jump into the * - * real allocation loop. * - *********************************************************/ - line_offset = item_offset = 0; - - /* prepend extra space to item_offset/line_offset for SPREAD_END */ - if (item_spreading == GTK_WRAP_BOX_SPREAD_END) - item_offset += extra_pixels; - - if (line_spreading == GTK_WRAP_BOX_SPREAD_END) - line_offset += extra_line_pixels; - - /* Get the allocation size for the first line */ - if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS) - this_line_size = line_size; - else - { - this_line_size = line_sizes[0].minimum_size; - - if (line_spreading == GTK_WRAP_BOX_SPREAD_EXPAND) - { - this_line_size += extra_per_line; - - if (extra_line_extra > 0) - this_line_size++; - } - } - - for (i = 0, line_count = 0, list = priv->children; list; list = list->next) - { - GtkWrapBoxChild *child = list->data; - gint position; - gint this_item_size; - - if (!gtk_widget_get_visible (child->widget)) - continue; - - /* Get item position */ - position = i % line_length; - - /* adjust the line_offset/count at the beginning of each new line */ - if (i > 0 && position == 0) - { - /* Push the line_offset */ - line_offset += this_line_size + line_spacing; - - if (line_spreading == GTK_WRAP_BOX_SPREAD_EVEN) - { - line_offset += extra_per_line; - - if (line_count < extra_line_extra) - line_offset++; - } - - line_count++; - - /* Get the new line size */ - if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS) - this_line_size = line_size; - else - { - this_line_size = line_sizes[line_count].minimum_size; - - if (line_spreading == GTK_WRAP_BOX_SPREAD_EXPAND) - { - this_line_size += extra_per_line; - - if (line_count < extra_line_extra) - this_line_size++; - } - } - - item_offset = 0; - - if (item_spreading == GTK_WRAP_BOX_SPREAD_END) - { - item_offset += extra_pixels; - - /* If we're on the last line, prepend the space for - * any leading items */ - if (line_count == n_lines -1) - { - gint extra_items = n_children % line_length; - - if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS) - { - item_offset += item_size * (line_length - extra_items); - item_offset += item_spacing * (line_length - extra_items); - } - else - { - gint j; - - for (j = 0; j < (line_length - extra_items); j++) - { - item_offset += item_sizes[j].minimum_size; - item_offset += item_spacing; - } - } - } - } - } - - /* Push the index along for the last line when spreading to the end */ - if (item_spreading == GTK_WRAP_BOX_SPREAD_END && - line_count == n_lines -1) - { - gint extra_items = n_children % line_length; - - position += line_length - extra_items; - } - - if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS) - this_item_size = item_size; - else /* aligned mode */ - this_item_size = item_sizes[position].minimum_size; - - if (item_spreading == GTK_WRAP_BOX_SPREAD_EXPAND) - { - this_item_size += extra_per_item; - - if (position < extra_extra) - this_item_size++; - } - - /* Do the actual allocation */ - allocate_child (box, child, item_offset, line_offset, this_item_size, this_line_size); - - item_offset += this_item_size; - item_offset += item_spacing; - - /* deal with extra spacing here */ - if (item_spreading == GTK_WRAP_BOX_SPREAD_EVEN) - { - item_offset += extra_per_item; - - if (position < extra_extra) - item_offset++; - } - - i++; - } - - g_free (item_sizes); - g_free (line_sizes); - } - else /* GTK_WRAP_ALLOCATE_FREE */ - { - /* Here we just fit as many children as we can allocate their natural size to - * on each line and add the heights for each of them on each line */ - GtkRequestedSize requested; - GtkRequestedSize *sizes = NULL; - GList *list = priv->children; - gboolean first_line = TRUE; - gint i, line_count = 0; - gint line_offset, item_offset; - gint extra_per_line = 0, extra_line_extra = 0; - gint extra_pixels; - GArray *array; - - array = g_array_new (0, TRUE, sizeof (GtkRequestedSize)); - - while (list != NULL) - { - GArray *line_array; - AllocatedLine *line; - - list = - get_largest_size_for_free_line_in_opposing_orientation (box, priv->orientation, - list, min_items, avail_size, - &requested.minimum_size, - &requested.natural_size, - &extra_pixels, - &line_array); - - /* Its possible a line is made of completely invisible children */ - if (requested.natural_size > 0) - { - if (first_line) - first_line = FALSE; - else - avail_other_size -= line_spacing; - - avail_other_size -= requested.minimum_size; - - line = g_slice_new0 (AllocatedLine); - line->requested = line_array; - line->extra_pixels = extra_pixels; - - requested.data = line; - - g_array_append_val (array, requested); - } - } - - /* Distribute space among lines naturally */ - sizes = (GtkRequestedSize *)array->data; - avail_other_size = gtk_distribute_natural_allocation (avail_other_size, array->len, sizes); - - /* Calculate expand space per line */ - if (line_spreading == GTK_WRAP_BOX_SPREAD_EVEN) - { - extra_per_line = avail_other_size / MAX (array->len -1, 1); - extra_line_extra = avail_other_size % MAX (array->len -1, 1); - } - else if (line_spreading == GTK_WRAP_BOX_SPREAD_EXPAND) - { - extra_per_line = avail_other_size / array->len; - extra_line_extra = avail_other_size % array->len; - } - - if (line_spreading == GTK_WRAP_BOX_SPREAD_END) - line_offset = avail_other_size; - else - line_offset = 0; - - for (line_count = 0; line_count < array->len; line_count++) - { - AllocatedLine *line = (AllocatedLine *)sizes[line_count].data; - GArray *line_array = line->requested; - GtkRequestedSize *line_sizes = (GtkRequestedSize *)line_array->data; - gint line_size = sizes[line_count].minimum_size; - gint extra_per_item = 0; - gint extra_extra = 0; - - /* Set line start offset */ - item_offset = 0; - - if (line_spreading == GTK_WRAP_BOX_SPREAD_EXPAND) - { - line_size += extra_per_line; - - if (line_count < extra_line_extra) - line_size++; - } - - if (item_spreading == GTK_WRAP_BOX_SPREAD_END) - item_offset += line->extra_pixels; - else if (item_spreading == GTK_WRAP_BOX_SPREAD_EVEN) - { - extra_per_item = line->extra_pixels / MAX (line_array->len -1, 1); - extra_extra = line->extra_pixels % MAX (line_array->len -1, 1); - } - - for (i = 0; i < line_array->len; i++) - { - GtkWrapBoxChild *child = line_sizes[i].data; - gint item_size = line_sizes[i].minimum_size; - - /* Do the actual allocation */ - allocate_child (box, child, item_offset, line_offset, item_size, line_size); - - /* Add extra space evenly between children */ - if (item_spreading == GTK_WRAP_BOX_SPREAD_EVEN) - { - item_offset += extra_per_item; - if (i < extra_extra) - item_offset++; - } - - /* Move item cursor along for the next allocation */ - item_offset += item_spacing; - item_offset += item_size; - } - - /* New line, increment offset and reset item cursor */ - line_offset += line_spacing; - line_offset += line_size; - - if (line_spreading == GTK_WRAP_BOX_SPREAD_EVEN) - { - line_offset += extra_per_line; - - if (line_count < extra_line_extra) - line_offset++; - } - - /* Free the array for this line now its not needed anymore */ - g_array_free (line_array, TRUE); - g_slice_free (AllocatedLine, line); - } - - g_array_free (array, TRUE); - } -} - -/***************************************************** - * GtkContainerClass * - *****************************************************/ -static void -gtk_wrap_box_add (GtkContainer *container, - GtkWidget *widget) -{ - gtk_wrap_box_insert_child (GTK_WRAP_BOX (container), widget, -1, 0); -} - -static gint -find_child_in_list (GtkWrapBoxChild *child_in_list, - GtkWidget *search) -{ - return (child_in_list->widget == search) ? 0 : -1; -} - -static void -gtk_wrap_box_remove (GtkContainer *container, - GtkWidget *widget) -{ - GtkWrapBox *box = GTK_WRAP_BOX (container); - GtkWrapBoxPrivate *priv = box->priv; - GList *list; - - list = g_list_find_custom (priv->children, widget, - (GCompareFunc)find_child_in_list); - - if (list) - { - GtkWrapBoxChild *child = list->data; - gboolean was_visible = gtk_widget_get_visible (widget); - - gtk_widget_unparent (widget); - - g_slice_free (GtkWrapBoxChild, child); - priv->children = g_list_delete_link (priv->children, list); - - if (was_visible && gtk_widget_get_visible (GTK_WIDGET (container))) - gtk_widget_queue_resize (GTK_WIDGET (container)); - } -} - -static void -gtk_wrap_box_forall (GtkContainer *container, - gboolean include_internals, - GtkCallback callback, - gpointer callback_data) -{ - GtkWrapBox *box = GTK_WRAP_BOX (container); - GtkWrapBoxPrivate *priv = box->priv; - GtkWrapBoxChild *child; - GList *list; - - for (list = priv->children; list; list = list->next) - { - child = list->data; - - (* callback) (child->widget, callback_data); - } -} - -static GType -gtk_wrap_box_child_type (GtkContainer *container) -{ - return GTK_TYPE_WIDGET; -} - -static void -gtk_wrap_box_set_child_property (GtkContainer *container, - GtkWidget *widget, - guint property_id, - const GValue *value, - GParamSpec *pspec) -{ - GtkWrapBox *box = GTK_WRAP_BOX (container); - GtkWrapBoxPrivate *priv = box->priv; - GtkWrapBoxChild *child; - GList *list; - - list = g_list_find_custom (priv->children, widget, - (GCompareFunc)find_child_in_list); - g_return_if_fail (list != NULL); - - child = list->data; - - switch (property_id) - { - case CHILD_PROP_PACKING: - child->packing = g_value_get_flags (value); - break; - default: - GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec); - break; - } - - if (gtk_widget_get_visible (widget) && - gtk_widget_get_visible (GTK_WIDGET (box))) - gtk_widget_queue_resize (widget); -} - -static void -gtk_wrap_box_get_child_property (GtkContainer *container, - GtkWidget *widget, - guint property_id, - GValue *value, - GParamSpec *pspec) -{ - GtkWrapBox *box = GTK_WRAP_BOX (container); - GtkWrapBoxPrivate *priv = box->priv; - GtkWrapBoxChild *child; - GList *list; - - list = g_list_find_custom (priv->children, widget, - (GCompareFunc)find_child_in_list); - g_return_if_fail (list != NULL); - - child = list->data; - - switch (property_id) - { - case CHILD_PROP_PACKING: - g_value_set_flags (value, child->packing); - break; - default: - GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec); - break; - } -} - -/***************************************************** - * size requests * - *****************************************************/ - - -static GtkSizeRequestMode -gtk_wrap_box_get_request_mode (GtkWidget *widget) -{ - GtkWrapBox *box = GTK_WRAP_BOX (widget); - GtkWrapBoxPrivate *priv = box->priv; - - return (priv->orientation == GTK_ORIENTATION_HORIZONTAL) ? - GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH : GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT; -} - -/* Gets the largest minimum and natural length of - * 'line_length' consecutive items */ -static void -get_largest_line_length (GtkWrapBox *box, - GtkOrientation orientation, - gint line_length, - gint *min_size, - gint *nat_size) -{ - GtkWrapBoxPrivate *priv = box->priv; - GList *list, *l; - gint max_min_size = 0; - gint max_nat_size = 0; - gint spacing; - - if (orientation == GTK_ORIENTATION_HORIZONTAL) - spacing = priv->horizontal_spacing; - else - spacing = priv->vertical_spacing; - - /* Get the largest size of 'line_length' consecutive items in the list. - */ - for (list = priv->children; list; list = list->next) - { - gint line_min = 0; - gint line_nat = 0; - gint i; - - for (l = list, i = 0; l && i < line_length; l = l->next) - { - GtkWrapBoxChild *child = l->data; - gint child_min, child_nat; - - if (!gtk_widget_get_visible (child->widget)) - continue; - - if (orientation == GTK_ORIENTATION_HORIZONTAL) - gtk_widget_get_preferred_width (child->widget, - &child_min, &child_nat); - else /* GTK_ORIENTATION_VERTICAL */ - gtk_widget_get_preferred_height (child->widget, - &child_min, &child_nat); - - line_min += child_min; - line_nat += child_nat; - - i++; - } - - max_min_size = MAX (max_min_size, line_min); - max_nat_size = MAX (max_nat_size, line_nat); - } - - max_min_size += (line_length - 1) * spacing; - max_nat_size += (line_length - 1) * spacing; - - if (min_size) - *min_size = max_min_size; - - if (nat_size) - *nat_size = max_nat_size; -} - -/* Gets the largest minimum and natural length of - * 'line_length' consecutive items when aligned into rows/columns */ -static void -get_largest_aligned_line_length (GtkWrapBox *box, - GtkOrientation orientation, - gint line_length, - gint *min_size, - gint *nat_size) -{ - GtkWrapBoxPrivate *priv = box->priv; - GList *list; - gint max_min_size = 0; - gint max_nat_size = 0; - gint spacing, i; - GtkRequestedSize *aligned_item_sizes; - - if (orientation == GTK_ORIENTATION_HORIZONTAL) - spacing = priv->horizontal_spacing; - else - spacing = priv->vertical_spacing; - - aligned_item_sizes = g_new0 (GtkRequestedSize, line_length); - - /* Get the largest sizes of each index in the line. - */ - for (list = priv->children, i = 0; list; list = list->next) - { - GtkWrapBoxChild *child = list->data; - gint child_min, child_nat; - - if (!gtk_widget_get_visible (child->widget)) - continue; - - if (orientation == GTK_ORIENTATION_HORIZONTAL) - gtk_widget_get_preferred_width (child->widget, - &child_min, &child_nat); - else /* GTK_ORIENTATION_VERTICAL */ - gtk_widget_get_preferred_height (child->widget, - &child_min, &child_nat); - - aligned_item_sizes[i % line_length].minimum_size = - MAX (aligned_item_sizes[i % line_length].minimum_size, child_min); - - aligned_item_sizes[i % line_length].natural_size = - MAX (aligned_item_sizes[i % line_length].natural_size, child_nat); - - i++; - } - - /* Add up the largest indexes */ - for (i = 0; i < line_length; i++) - { - max_min_size += aligned_item_sizes[i].minimum_size; - max_nat_size += aligned_item_sizes[i].natural_size; - } - - g_free (aligned_item_sizes); - - max_min_size += (line_length - 1) * spacing; - max_nat_size += (line_length - 1) * spacing; - - if (min_size) - *min_size = max_min_size; - - if (nat_size) - *nat_size = max_nat_size; -} - - -static void -gtk_wrap_box_get_preferred_width (GtkWidget *widget, - gint *minimum_size, - gint *natural_size) -{ - GtkWrapBox *box = GTK_WRAP_BOX (widget); - GtkWrapBoxPrivate *priv = box->priv; - gint min_item_width, nat_item_width; - gint min_items, nat_items; - gint min_width, nat_width; - - min_items = MAX (1, priv->minimum_line_children); - nat_items = MAX (min_items, priv->natural_line_children); - - if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) - { - min_width = nat_width = 0; - - if (priv->mode == GTK_WRAP_ALLOCATE_FREE || - priv->mode == GTK_WRAP_ALLOCATE_ALIGNED) - { - /* In FREE and ALIGNED modes; horizontally oriented boxes - * need enough width for the widest row */ - if (min_items == 1) - { - get_average_item_size (box, GTK_ORIENTATION_HORIZONTAL, - &min_item_width, &nat_item_width); - - min_width += min_item_width; - nat_width += nat_item_width; - } - else if (priv->mode == GTK_WRAP_ALLOCATE_FREE) - { - gint min_line_length, nat_line_length; - - get_largest_line_length (box, GTK_ORIENTATION_HORIZONTAL, min_items, - &min_line_length, &nat_line_length); - - if (nat_items > min_items) - get_largest_line_length (box, GTK_ORIENTATION_HORIZONTAL, nat_items, - NULL, &nat_line_length); - - min_width += min_line_length; - nat_width += nat_line_length; - } - else /* GTK_WRAP_MODE_ALIGNED */ - { - gint min_line_length, nat_line_length; - - get_largest_aligned_line_length (box, GTK_ORIENTATION_HORIZONTAL, min_items, - &min_line_length, &nat_line_length); - - if (nat_items > min_items) - get_largest_aligned_line_length (box, GTK_ORIENTATION_HORIZONTAL, nat_items, - NULL, &nat_line_length); - - min_width += min_line_length; - nat_width += nat_line_length; - } - } - else /* In HOMOGENEOUS mode; horizontally oriented boxs - * give the same width to all children */ - { - get_average_item_size (box, GTK_ORIENTATION_HORIZONTAL, - &min_item_width, &nat_item_width); - - min_width += min_item_width * min_items; - min_width += (min_items -1) * priv->horizontal_spacing; - - nat_width += nat_item_width * nat_items; - nat_width += (nat_items -1) * priv->horizontal_spacing; - } - } - else /* GTK_ORIENTATION_VERTICAL */ - { - /* Return the width for the minimum height */ - gint min_height; - - GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, &min_height, NULL); - GTK_WIDGET_GET_CLASS (widget)->get_preferred_width_for_height (widget, min_height, - &min_width, &nat_width); - - } - - if (minimum_size) - *minimum_size = min_width; - - if (natural_size) - *natural_size = nat_width; -} - -static void -gtk_wrap_box_get_preferred_height (GtkWidget *widget, - gint *minimum_size, - gint *natural_size) -{ - GtkWrapBox *box = GTK_WRAP_BOX (widget); - GtkWrapBoxPrivate *priv = box->priv; - gint min_item_height, nat_item_height; - gint min_items, nat_items; - gint min_height, nat_height; - - min_items = MAX (1, priv->minimum_line_children); - nat_items = MAX (min_items, priv->natural_line_children); - - if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) - { - /* Return the height for the minimum width */ - gint min_width; - - GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, NULL); - GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget, min_width, - &min_height, &nat_height); - } - else /* GTK_ORIENTATION_VERTICAL */ - { - min_height = nat_height = 0; - - if (priv->mode == GTK_WRAP_ALLOCATE_FREE || - priv->mode == GTK_WRAP_ALLOCATE_ALIGNED) - { - /* In FREE and ALIGNED modes; vertically oriented boxes - * need enough height for the tallest column */ - if (min_items == 1) - { - get_average_item_size (box, GTK_ORIENTATION_VERTICAL, - &min_item_height, &nat_item_height); - - min_height += min_item_height; - nat_height += nat_item_height; - } - else if (priv->mode == GTK_WRAP_ALLOCATE_FREE) - { - gint min_line_length, nat_line_length; - - get_largest_line_length (box, GTK_ORIENTATION_VERTICAL, min_items, - &min_line_length, &nat_line_length); - - if (nat_items > min_items) - get_largest_line_length (box, GTK_ORIENTATION_VERTICAL, nat_items, - NULL, &nat_line_length); - - min_height += min_line_length; - nat_height += nat_line_length; - } - else /* GTK_WRAP_ALLOCATE_ALIGNED */ - { - gint min_line_length, nat_line_length; - - get_largest_aligned_line_length (box, GTK_ORIENTATION_VERTICAL, min_items, - &min_line_length, &nat_line_length); - - if (nat_items > min_items) - get_largest_aligned_line_length (box, GTK_ORIENTATION_VERTICAL, nat_items, - NULL, &nat_line_length); - - min_height += min_line_length; - nat_height += nat_line_length; - } - - } - else /* In HOMOGENEOUS mode; vertically oriented boxs - * give the same height to all children */ - { - get_average_item_size (box, GTK_ORIENTATION_VERTICAL, - &min_item_height, &nat_item_height); - - min_height += min_item_height * min_items; - min_height += (min_items -1) * priv->vertical_spacing; - - nat_height += nat_item_height * nat_items; - nat_height += (nat_items -1) * priv->vertical_spacing; - } - } - - if (minimum_size) - *minimum_size = min_height; - - if (natural_size) - *natural_size = nat_height; -} - -static void -gtk_wrap_box_get_preferred_height_for_width (GtkWidget *widget, - gint width, - gint *minimum_height, - gint *natural_height) -{ - GtkWrapBox *box = GTK_WRAP_BOX (widget); - GtkWrapBoxPrivate *priv = box->priv; - gint min_item_width, nat_item_width; - gint min_items; - gint min_height, nat_height; - gint avail_size, n_children; - - min_items = MAX (1, priv->minimum_line_children); - - min_height = 0; - nat_height = 0; - - if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) - { - gint min_width; - - n_children = get_visible_children (box); - - /* Make sure its no smaller than the minimum */ - GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, NULL); - - avail_size = MAX (width, min_width); - - if (priv->mode == GTK_WRAP_ALLOCATE_ALIGNED || - priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS) - { - gint line_length; - gint item_size, extra_pixels; - - get_average_item_size (box, GTK_ORIENTATION_HORIZONTAL, &min_item_width, &nat_item_width); - - /* By default wrap at the natural item width */ - line_length = avail_size / (nat_item_width + priv->horizontal_spacing); - - /* After the above aproximation, check if we cant fit one more on the line */ - if (line_length * priv->horizontal_spacing + (line_length + 1) * nat_item_width <= avail_size) - line_length++; - - /* Its possible we were allocated just less than the natural width of the - * minimum item wrap length */ - line_length = MAX (min_items, line_length); - - /* Now we need the real item allocation size */ - item_size = (avail_size - (line_length - 1) * priv->horizontal_spacing) / line_length; - - /* Cut out the expand space if we're not distributing any */ - if (priv->horizontal_spreading != GTK_WRAP_BOX_SPREAD_EXPAND) - { - item_size = MIN (item_size, nat_item_width); - extra_pixels = 0; - } - else - /* Collect the extra pixels for expand children */ - extra_pixels = (avail_size - (line_length - 1) * priv->horizontal_spacing) % line_length; - - if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS) - { - gint min_item_height, nat_item_height; - gint lines; - - /* Here we just use the largest height-for-width and - * add up the size accordingly */ - get_largest_size_for_opposing_orientation (box, GTK_ORIENTATION_HORIZONTAL, item_size, - &min_item_height, &nat_item_height); - - /* Round up how many lines we need to allocate for */ - lines = n_children / line_length; - if ((n_children % line_length) > 0) - lines++; - - min_height = min_item_height * lines; - nat_height = nat_item_height * lines; - - min_height += (lines - 1) * priv->vertical_spacing; - nat_height += (lines - 1) * priv->vertical_spacing; - } - else /* GTK_WRAP_ALLOCATE_ALIGNED */ - { - GList *list = priv->children; - gint min_line_height, nat_line_height, i; - gboolean first_line = TRUE; - GtkRequestedSize *item_sizes; - - /* First get the size each set of items take to span the line - * when aligning the items above and below after wrapping. - */ - item_sizes = fit_aligned_item_requests (box, priv->orientation, avail_size, - priv->horizontal_spacing, &line_length, n_children); - - - /* Get the available remaining size */ - avail_size -= (line_length - 1) * priv->horizontal_spacing; - for (i = 0; i < line_length; i++) - avail_size -= item_sizes[i].minimum_size; - - extra_pixels = gtk_distribute_natural_allocation (avail_size, line_length, item_sizes); - - while (list != NULL) - { - list = - get_largest_size_for_line_in_opposing_orientation (box, GTK_ORIENTATION_HORIZONTAL, - list, line_length, - item_sizes, extra_pixels, - &min_line_height, &nat_line_height); - - /* Its possible the line only had invisible widgets */ - if (nat_line_height > 0) - { - if (first_line) - first_line = FALSE; - else - { - min_height += priv->vertical_spacing; - nat_height += priv->vertical_spacing; - } - - min_height += min_line_height; - nat_height += nat_line_height; - } - } - - g_free (item_sizes); - } - } - else /* GTK_WRAP_ALLOCATE_FREE */ - { - /* Here we just fit as many children as we can allocate their natural size to - * on each line and add the heights for each of them on each line */ - GList *list = priv->children; - gint min_line_height = 0, nat_line_height = 0; - gboolean first_line = TRUE; - - while (list != NULL) - { - list = - get_largest_size_for_free_line_in_opposing_orientation (box, GTK_ORIENTATION_HORIZONTAL, - list, min_items, avail_size, - &min_line_height, &nat_line_height, - NULL, NULL); - - /* Its possible the last line only had invisible widgets */ - if (nat_line_height > 0) - { - if (first_line) - first_line = FALSE; - else - { - min_height += priv->vertical_spacing; - nat_height += priv->vertical_spacing; - } - - min_height += min_line_height; - nat_height += nat_line_height; - } - } - } - } - else /* GTK_ORIENTATION_VERTICAL */ - { - /* Return the minimum height */ - GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, &min_height, &nat_height); - } - - if (minimum_height) - *minimum_height = min_height; - - if (natural_height) - *natural_height = nat_height; -} - -static void -gtk_wrap_box_get_preferred_width_for_height (GtkWidget *widget, - gint height, - gint *minimum_width, - gint *natural_width) -{ - GtkWrapBox *box = GTK_WRAP_BOX (widget); - GtkWrapBoxPrivate *priv = box->priv; - gint min_item_height, nat_item_height; - gint min_items; - gint min_width, nat_width; - gint avail_size, n_children; - - min_items = MAX (1, priv->minimum_line_children); - - min_width = 0; - nat_width = 0; - - if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) - { - /* Return the minimum width */ - GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, &nat_width); - } - else /* GTK_ORIENTATION_VERTICAL */ - { - gint min_height; - - n_children = get_visible_children (box); - - /* Make sure its no smaller than the minimum */ - GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, &min_height, NULL); - - avail_size = MAX (height, min_height); - - if (priv->mode == GTK_WRAP_ALLOCATE_ALIGNED || - priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS) - { - gint line_length; - gint item_size, extra_pixels; - - get_average_item_size (box, GTK_ORIENTATION_VERTICAL, &min_item_height, &nat_item_height); - - /* By default wrap at the natural item width */ - line_length = avail_size / (nat_item_height + priv->vertical_spacing); - - /* After the above aproximation, check if we cant fit one more on the line */ - if (line_length * priv->vertical_spacing + (line_length + 1) * nat_item_height <= avail_size) - line_length++; - - /* Its possible we were allocated just less than the natural width of the - * minimum item wrap length */ - line_length = MAX (min_items, line_length); - - /* Now we need the real item allocation size */ - item_size = (avail_size - (line_length - 1) * priv->vertical_spacing) / line_length; - - /* Cut out the expand space if we're not distributing any */ - if (priv->vertical_spreading != GTK_WRAP_BOX_SPREAD_EXPAND) - { - item_size = MIN (item_size, nat_item_height); - extra_pixels = 0; - } - else - /* Collect the extra pixels for expand children */ - extra_pixels = (avail_size - (line_length - 1) * priv->vertical_spacing) % line_length; - - if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS) - { - gint min_item_width, nat_item_width; - gint lines; - - /* Here we just use the largest height-for-width and - * add up the size accordingly */ - get_largest_size_for_opposing_orientation (box, GTK_ORIENTATION_VERTICAL, item_size, - &min_item_width, &nat_item_width); - - /* Round up how many lines we need to allocate for */ - n_children = get_visible_children (box); - lines = n_children / line_length; - if ((n_children % line_length) > 0) - lines++; - - min_width = min_item_width * lines; - nat_width = nat_item_width * lines; - - min_width += (lines - 1) * priv->horizontal_spacing; - nat_width += (lines - 1) * priv->horizontal_spacing; - } - else /* GTK_WRAP_ALLOCATE_ALIGNED */ - { - GList *list = priv->children; - gint min_line_width, nat_line_width, i; - gboolean first_line = TRUE; - GtkRequestedSize *item_sizes; - - /* First get the size each set of items take to span the line - * when aligning the items above and below after wrapping. - */ - item_sizes = fit_aligned_item_requests (box, priv->orientation, avail_size, - priv->vertical_spacing, &line_length, n_children); - - /* Get the available remaining size */ - avail_size -= (line_length - 1) * priv->horizontal_spacing; - for (i = 0; i < line_length; i++) - avail_size -= item_sizes[i].minimum_size; - - extra_pixels = gtk_distribute_natural_allocation (avail_size, line_length, item_sizes); - - while (list != NULL) - { - list = - get_largest_size_for_line_in_opposing_orientation (box, GTK_ORIENTATION_VERTICAL, - list, line_length, - item_sizes, extra_pixels, - &min_line_width, &nat_line_width); - - /* Its possible the last line only had invisible widgets */ - if (nat_line_width > 0) - { - if (first_line) - first_line = FALSE; - else - { - min_width += priv->horizontal_spacing; - nat_width += priv->horizontal_spacing; - } - - min_width += min_line_width; - nat_width += nat_line_width; - } - } - g_free (item_sizes); - } - } - else /* GTK_WRAP_ALLOCATE_FREE */ - { - /* Here we just fit as many children as we can allocate their natural size to - * on each line and add the heights for each of them on each line */ - GList *list = priv->children; - gint min_line_width = 0, nat_line_width = 0; - gboolean first_line = TRUE; - - while (list != NULL) - { - list = - get_largest_size_for_free_line_in_opposing_orientation (box, GTK_ORIENTATION_VERTICAL, - list, min_items, avail_size, - &min_line_width, &nat_line_width, - NULL, NULL); - - /* Its possible the last line only had invisible widgets */ - if (nat_line_width > 0) - { - if (first_line) - first_line = FALSE; - else - { - min_width += priv->horizontal_spacing; - nat_width += priv->horizontal_spacing; - } - - min_width += min_line_width; - nat_width += nat_line_width; - } - } - } - } - - if (minimum_width) - *minimum_width = min_width; - - if (natural_width) - *natural_width = nat_width; -} - -/***************************************************** - * API * - *****************************************************/ - -/** - * gtk_wrap_box_new: - * @mode: The #GtkWrapAllocationMode to use - * @horizontal_spreading: The horizontal #GtkWrapBoxSpreading policy to use - * @vertical_spreading: The vertical #GtkWrapBoxSpreading policy to use - * @horizontal_spacing: The horizontal spacing to add between children - * @vertical_spacing: The vertical spacing to add between children - * - * Creates an #GtkWrapBox. - * - * Returns: A new #GtkWrapBox container - */ -GtkWidget * -gtk_wrap_box_new (GtkWrapAllocationMode mode, - GtkWrapBoxSpreading horizontal_spreading, - GtkWrapBoxSpreading vertical_spreading, - guint horizontal_spacing, - guint vertical_spacing) -{ - return (GtkWidget *)g_object_new (GTK_TYPE_WRAP_BOX, - "allocation-mode", mode, - "horizontal-spreading", horizontal_spreading, - "vertical-spreading", vertical_spreading, - "vertical-spacing", vertical_spacing, - "horizontal-spacing", horizontal_spacing, - NULL); -} - -/** - * gtk_wrap_box_set_allocation_mode: - * @box: An #GtkWrapBox - * @mode: The #GtkWrapAllocationMode to use. - * - * Sets the allocation mode for @box's children. - */ -void -gtk_wrap_box_set_allocation_mode (GtkWrapBox *box, - GtkWrapAllocationMode mode) -{ - GtkWrapBoxPrivate *priv; - - g_return_if_fail (GTK_IS_WRAP_BOX (box)); - - priv = box->priv; - - if (priv->mode != mode) - { - priv->mode = mode; - - gtk_widget_queue_resize (GTK_WIDGET (box)); - - g_object_notify (G_OBJECT (box), "allocation-mode"); - } -} - -/** - * gtk_wrap_box_get_allocation_mode: - * @box: An #GtkWrapBox - * - * Gets the allocation mode. - * - * Returns: The #GtkWrapAllocationMode for @box. - */ -GtkWrapAllocationMode -gtk_wrap_box_get_allocation_mode (GtkWrapBox *box) -{ - g_return_val_if_fail (GTK_IS_WRAP_BOX (box), FALSE); - - return box->priv->mode; -} - - -/** - * gtk_wrap_box_set_horizontal_spreading: - * @box: An #GtkWrapBox - * @spreading: The #GtkWrapBoxSpreading to use. - * - * Sets the horizontal spreading mode for @box's children. - */ -void -gtk_wrap_box_set_horizontal_spreading (GtkWrapBox *box, - GtkWrapBoxSpreading spreading) -{ - GtkWrapBoxPrivate *priv; - - g_return_if_fail (GTK_IS_WRAP_BOX (box)); - - priv = box->priv; - - if (priv->horizontal_spreading != spreading) - { - priv->horizontal_spreading = spreading; - - gtk_widget_queue_resize (GTK_WIDGET (box)); - - g_object_notify (G_OBJECT (box), "horizontal-spreading"); - } -} - -/** - * gtk_wrap_box_get_horizontal_spreading: - * @box: An #GtkWrapBox - * - * Gets the horizontal spreading mode. - * - * Returns: The horizontal #GtkWrapBoxSpreading for @box. - */ -GtkWrapBoxSpreading -gtk_wrap_box_get_horizontal_spreading (GtkWrapBox *box) -{ - g_return_val_if_fail (GTK_IS_WRAP_BOX (box), FALSE); - - return box->priv->horizontal_spreading; -} - - -/** - * gtk_wrap_box_set_vertical_spreading: - * @box: An #GtkWrapBox - * @spreading: The #GtkWrapBoxSpreading to use. - * - * Sets the vertical spreading mode for @box's children. - */ -void -gtk_wrap_box_set_vertical_spreading (GtkWrapBox *box, - GtkWrapBoxSpreading spreading) -{ - GtkWrapBoxPrivate *priv; - - g_return_if_fail (GTK_IS_WRAP_BOX (box)); - - priv = box->priv; - - if (priv->vertical_spreading != spreading) - { - priv->vertical_spreading = spreading; - - gtk_widget_queue_resize (GTK_WIDGET (box)); - - g_object_notify (G_OBJECT (box), "vertical-spreading"); - } -} - -/** - * gtk_wrap_box_get_vertical_spreading: - * @box: An #GtkWrapBox - * - * Gets the vertical spreading mode. - * - * Returns: The vertical #GtkWrapBoxSpreading for @box. - */ -GtkWrapBoxSpreading -gtk_wrap_box_get_vertical_spreading (GtkWrapBox *box) -{ - g_return_val_if_fail (GTK_IS_WRAP_BOX (box), FALSE); - - return box->priv->vertical_spreading; -} - - -/** - * gtk_wrap_box_set_vertical_spacing: - * @box: An #GtkWrapBox - * @spacing: The spacing to use. - * - * Sets the vertical space to add between children. - */ -void -gtk_wrap_box_set_vertical_spacing (GtkWrapBox *box, - guint spacing) -{ - GtkWrapBoxPrivate *priv; - - g_return_if_fail (GTK_IS_WRAP_BOX (box)); - - priv = box->priv; - - if (priv->vertical_spacing != spacing) - { - priv->vertical_spacing = spacing; - - gtk_widget_queue_resize (GTK_WIDGET (box)); - - g_object_notify (G_OBJECT (box), "vertical-spacing"); - } -} - -/** - * gtk_wrap_box_get_vertical_spacing: - * @box: An #GtkWrapBox - * - * Gets the vertical spacing. - * - * Returns: The vertical spacing. - */ -guint -gtk_wrap_box_get_vertical_spacing (GtkWrapBox *box) -{ - g_return_val_if_fail (GTK_IS_WRAP_BOX (box), FALSE); - - return box->priv->vertical_spacing; -} - -/** - * gtk_wrap_box_set_horizontal_spacing: - * @box: An #GtkWrapBox - * @spacing: The spacing to use. - * - * Sets the horizontal space to add between children. - */ -void -gtk_wrap_box_set_horizontal_spacing (GtkWrapBox *box, - guint spacing) -{ - GtkWrapBoxPrivate *priv; - - g_return_if_fail (GTK_IS_WRAP_BOX (box)); - - priv = box->priv; - - if (priv->horizontal_spacing != spacing) - { - priv->horizontal_spacing = spacing; - - gtk_widget_queue_resize (GTK_WIDGET (box)); - - g_object_notify (G_OBJECT (box), "horizontal-spacing"); - } -} - -/** - * gtk_wrap_box_get_horizontal_spacing: - * @box: An #GtkWrapBox - * - * Gets the horizontal spacing. - * - * Returns: The horizontal spacing. - */ -guint -gtk_wrap_box_get_horizontal_spacing (GtkWrapBox *box) -{ - g_return_val_if_fail (GTK_IS_WRAP_BOX (box), FALSE); - - return box->priv->horizontal_spacing; -} - -/** - * gtk_wrap_box_set_minimum_line_children: - * @box: An #GtkWrapBox - * @n_children: The minimum amount of children per line. - * - * Sets the minimum amount of children to line up - * in @box's orientation before wrapping. - */ -void -gtk_wrap_box_set_minimum_line_children (GtkWrapBox *box, - guint n_children) -{ - GtkWrapBoxPrivate *priv; - - g_return_if_fail (GTK_IS_WRAP_BOX (box)); - - priv = box->priv; - - if (priv->minimum_line_children != n_children) - { - priv->minimum_line_children = n_children; - - gtk_widget_queue_resize (GTK_WIDGET (box)); - - g_object_notify (G_OBJECT (box), "minimum-line-children"); - } -} - -/** - * gtk_wrap_box_get_minimum_line_children: - * @box: An #GtkWrapBox - * - * Gets the minimum amount of children per line. - * - * Returns: The minimum amount of children per line. - */ -guint -gtk_wrap_box_get_minimum_line_children (GtkWrapBox *box) -{ - g_return_val_if_fail (GTK_IS_WRAP_BOX (box), FALSE); - - return box->priv->minimum_line_children; -} - -/** - * gtk_wrap_box_set_natural_line_children: - * @box: An #GtkWrapBox - * @n_children: The natural amount of children per line. - * - * Sets the natural length of items to request and - * allocate space for in @box's orientation. - * - * Setting the natural amount of children per line - * limits the overall natural size request to be no more - * than @n_children items long in the given orientation. - */ -void -gtk_wrap_box_set_natural_line_children (GtkWrapBox *box, - guint n_children) -{ - GtkWrapBoxPrivate *priv; - - g_return_if_fail (GTK_IS_WRAP_BOX (box)); - - priv = box->priv; - - if (priv->natural_line_children != n_children) - { - priv->natural_line_children = n_children; - - gtk_widget_queue_resize (GTK_WIDGET (box)); - - g_object_notify (G_OBJECT (box), "natural-line-children"); - } -} - -/** - * gtk_wrap_box_get_natural_line_children: - * @box: An #GtkWrapBox - * - * Gets the natural amount of children per line. - * - * Returns: The natural amount of children per line. - */ -guint -gtk_wrap_box_get_natural_line_children (GtkWrapBox *box) -{ - g_return_val_if_fail (GTK_IS_WRAP_BOX (box), FALSE); - - return box->priv->natural_line_children; -} - - -/** - * gtk_wrap_box_insert_child: - * @box: And #GtkWrapBox - * @widget: the child #GtkWidget to add - * @index: the position in the child list to insert, specify -1 to append to the list. - * @packing: The #GtkWrapBoxPacking options to use. - * - * Adds a child to an #GtkWrapBox with its packing options set - * - */ -void -gtk_wrap_box_insert_child (GtkWrapBox *box, - GtkWidget *widget, - gint index, - GtkWrapBoxPacking packing) -{ - GtkWrapBoxPrivate *priv; - GtkWrapBoxChild *child; - GList *list; - - g_return_if_fail (GTK_IS_WRAP_BOX (box)); - g_return_if_fail (GTK_IS_WIDGET (widget)); - - priv = box->priv; - - list = g_list_find_custom (priv->children, widget, - (GCompareFunc)find_child_in_list); - g_return_if_fail (list == NULL); - - child = g_slice_new0 (GtkWrapBoxChild); - child->widget = widget; - child->packing = packing; - - priv->children = g_list_insert (priv->children, child, index); - - gtk_widget_set_parent (widget, GTK_WIDGET (box)); -} - -/** - * gtk_wrap_box_reorder_child: - * @box: An #GtkWrapBox - * @widget: The child to reorder - * @index: The new child position - * - * Reorders the child @widget in @box's list of children. - */ -void -gtk_wrap_box_reorder_child (GtkWrapBox *box, - GtkWidget *widget, - guint index) -{ - GtkWrapBoxPrivate *priv; - GtkWrapBoxChild *child; - GList *list; - - g_return_if_fail (GTK_IS_WRAP_BOX (box)); - g_return_if_fail (GTK_IS_WIDGET (widget)); - - priv = box->priv; - - list = g_list_find_custom (priv->children, widget, - (GCompareFunc)find_child_in_list); - g_return_if_fail (list != NULL); - - if (g_list_position (priv->children, list) != index) - { - child = list->data; - priv->children = g_list_delete_link (priv->children, list); - priv->children = g_list_insert (priv->children, child, index); - - gtk_widget_queue_resize (GTK_WIDGET (box)); - } -} diff --git a/gtk/gtkwrapbox.h b/gtk/gtkwrapbox.h deleted file mode 100644 index 266a63fa85..0000000000 --- a/gtk/gtkwrapbox.h +++ /dev/null @@ -1,102 +0,0 @@ -/* - * Copyright (C) 2010 Openismus GmbH - * - * Authors: - * Tristan Van Berkom - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - */ - -#ifndef __GTK_WRAP_BOX_H__ -#define __GTK_WRAP_BOX_H__ - -#include - -G_BEGIN_DECLS - - -#define GTK_TYPE_WRAP_BOX (gtk_wrap_box_get_type ()) -#define GTK_WRAP_BOX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WRAP_BOX, GtkWrapBox)) -#define GTK_WRAP_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WRAP_BOX, GtkWrapBoxClass)) -#define GTK_IS_WRAP_BOX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WRAP_BOX)) -#define GTK_IS_WRAP_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WRAP_BOX)) -#define GTK_WRAP_BOX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WRAP_BOX, GtkWrapBoxClass)) - -typedef struct _GtkWrapBox GtkWrapBox; -typedef struct _GtkWrapBoxPrivate GtkWrapBoxPrivate; -typedef struct _GtkWrapBoxClass GtkWrapBoxClass; - -struct _GtkWrapBox -{ - GtkContainer container; - - /*< private >*/ - GtkWrapBoxPrivate *priv; -}; - -struct _GtkWrapBoxClass -{ - GtkContainerClass parent_class; -}; - -GType gtk_wrap_box_get_type (void) G_GNUC_CONST; - -GtkWidget *gtk_wrap_box_new (GtkWrapAllocationMode mode, - GtkWrapBoxSpreading horizontal_spreading, - GtkWrapBoxSpreading vertical_spreading, - guint horizontal_spacing, - guint vertical_spacing); -void gtk_wrap_box_set_allocation_mode (GtkWrapBox *box, - GtkWrapAllocationMode mode); -GtkWrapAllocationMode gtk_wrap_box_get_allocation_mode (GtkWrapBox *box); - -void gtk_wrap_box_set_horizontal_spreading (GtkWrapBox *box, - GtkWrapBoxSpreading spreading); -GtkWrapBoxSpreading gtk_wrap_box_get_horizontal_spreading (GtkWrapBox *box); - -void gtk_wrap_box_set_vertical_spreading (GtkWrapBox *box, - GtkWrapBoxSpreading spreading); -GtkWrapBoxSpreading gtk_wrap_box_get_vertical_spreading (GtkWrapBox *box); - -void gtk_wrap_box_set_vertical_spacing (GtkWrapBox *box, - guint spacing); -guint gtk_wrap_box_get_vertical_spacing (GtkWrapBox *box); - -void gtk_wrap_box_set_horizontal_spacing (GtkWrapBox *box, - guint spacing); -guint gtk_wrap_box_get_horizontal_spacing (GtkWrapBox *box); - -void gtk_wrap_box_set_minimum_line_children (GtkWrapBox *box, - guint n_children); -guint gtk_wrap_box_get_minimum_line_children (GtkWrapBox *box); - -void gtk_wrap_box_set_natural_line_children (GtkWrapBox *box, - guint n_children); -guint gtk_wrap_box_get_natural_line_children (GtkWrapBox *box); - -void gtk_wrap_box_insert_child (GtkWrapBox *box, - GtkWidget *widget, - gint index, - GtkWrapBoxPacking packing); - -void gtk_wrap_box_reorder_child (GtkWrapBox *box, - GtkWidget *widget, - guint index); - -G_END_DECLS - - -#endif /* __GTK_WRAP_BOX_H__ */ diff --git a/tests/Makefile.am b/tests/Makefile.am index b607ad53eb..2b5845863f 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -91,8 +91,7 @@ noinst_PROGRAMS = $(TEST_PROGS) \ testgrouping \ testtooltips \ testexpander \ - testvolumebutton \ - testwrapbox + testvolumebutton if USE_X11 noinst_PROGRAMS += testapplication testerrors @@ -176,7 +175,6 @@ testactions_DEPENDENCIES = $(TEST_DEPS) testgrouping_DEPENDENCIES = $(TEST_DEPS) testtooltips_DEPENDENCIES = $(TEST_DEPS) testvolumebutton_DEPENDENCIES = $(TEST_DEPS) -testwrapbox_DEPENDENCIES = $(TEST_DEPS) testwindows_DEPENDENCIES = $(TEST_DEPS) testexpander_DEPENDENCIES = $(TEST_DEPS) @@ -248,7 +246,6 @@ testactions_LDADD = $(LDADDS) testgrouping_LDADD = $(LDADDS) testtooltips_LDADD = $(LDADDS) testvolumebutton_LDADD = $(LDADDS) -testwrapbox_LDADD = $(LDADDS) testwindows_LDADD = $(LDADDS) testexpander_LDADD = $(LDADDS) @@ -351,9 +348,6 @@ testrecentchoosermenu_SOURCES = \ testvolumebutton_SOURCES = \ testvolumebutton.c -testwrapbox_SOURCES = \ - testwrapbox.c - testoffscreen_SOURCES = \ gtkoffscreenbox.c \ gtkoffscreenbox.h \ diff --git a/tests/testwrapbox.c b/tests/testwrapbox.c deleted file mode 100644 index 0fb92e119d..0000000000 --- a/tests/testwrapbox.c +++ /dev/null @@ -1,496 +0,0 @@ -/* testwrapbox.c - * Copyright (C) 2010 Openismus GmbH - * - * Author: - * Tristan Van Berkom - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - */ - -#include - -enum { - SIMPLE_ITEMS = 0, - WRAPPY_ITEMS, - STOCK_ITEMS -}; - -#define INITIAL_ALLOCATION_MODE GTK_WRAP_ALLOCATE_HOMOGENEOUS -#define INITIAL_SPREADING GTK_WRAP_BOX_SPREAD_START -#define INITIAL_MINIMUM_LENGTH 3 -#define INITIAL_HSPACING 2 -#define INITIAL_VSPACING 2 - -static GtkWrapBox *the_wrapbox = NULL; -static gint items_type = SIMPLE_ITEMS; -static GtkOrientation text_orientation = GTK_ORIENTATION_HORIZONTAL; -static gboolean items_xexpand = TRUE; -static gboolean items_yexpand = TRUE; - - -static void -populate_wrapbox_simple (GtkWrapBox *wrapbox) -{ - GtkWidget *widget, *frame; - gint i; - - for (i = 0; i < 30; i++) - { - gchar *text = g_strdup_printf ("Item %02d", i); - - widget = gtk_label_new (text); - frame = gtk_frame_new (NULL); - gtk_widget_show (widget); - gtk_widget_show (frame); - - gtk_container_add (GTK_CONTAINER (frame), widget); - - if (text_orientation == GTK_ORIENTATION_VERTICAL) - gtk_label_set_angle (GTK_LABEL (widget), 90); - - gtk_wrap_box_insert_child (GTK_WRAP_BOX (wrapbox), frame, -1, - (items_xexpand ? GTK_WRAP_BOX_H_EXPAND : 0) | - (items_yexpand ? GTK_WRAP_BOX_V_EXPAND : 0)); - - g_free (text); - } -} - -static void -populate_wrapbox_wrappy (GtkWrapBox *wrapbox) -{ - GtkWidget *widget, *frame; - gint i; - - const gchar *strings[] = { - "These are", "some wrappy label", "texts", "of various", "lengths.", - "They should always be", "shown", "consecutively. Except it's", - "hard to say", "where exactly the", "label", "will wrap", "and where exactly", - "the actual", "container", "will wrap.", "This label is really really really long !", - "Let's add some more", "labels to the", - "mix. Just to", "make sure we", "got something to work", "with here." - }; - - for (i = 0; i < G_N_ELEMENTS (strings); i++) - { - widget = gtk_label_new (strings[i]); - frame = gtk_frame_new (NULL); - gtk_widget_show (widget); - gtk_widget_show (frame); - - if (text_orientation == GTK_ORIENTATION_VERTICAL) - gtk_label_set_angle (GTK_LABEL (widget), 90); - - gtk_container_add (GTK_CONTAINER (frame), widget); - - gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE); - gtk_label_set_line_wrap_mode (GTK_LABEL (widget), PANGO_WRAP_WORD); - gtk_label_set_width_chars (GTK_LABEL (widget), 10); - - gtk_wrap_box_insert_child (GTK_WRAP_BOX (wrapbox), frame, -1, - (items_xexpand ? GTK_WRAP_BOX_H_EXPAND : 0) | - (items_yexpand ? GTK_WRAP_BOX_V_EXPAND : 0)); - } -} - - -static void -populate_wrapbox_stock (GtkWrapBox *wrapbox) -{ - GtkWidget *widget; - static GSList *stock_ids = NULL; - GSList *l; - gint i; - - if (!stock_ids) - stock_ids = gtk_stock_list_ids (); - - for (i = 0, l = stock_ids; i < 30 && l != NULL; i++, l = l->next) - { - gchar *stock_id = l->data; - - widget = gtk_button_new_from_stock (stock_id); - gtk_widget_show (widget); - - gtk_wrap_box_insert_child (GTK_WRAP_BOX (wrapbox), widget, -1, - (items_xexpand ? GTK_WRAP_BOX_H_EXPAND : 0) | - (items_yexpand ? GTK_WRAP_BOX_V_EXPAND : 0)); - } -} - -static void -populate_items (GtkWrapBox *wrapbox) -{ - GList *children, *l; - - /* Remove all children first */ - children = gtk_container_get_children (GTK_CONTAINER (wrapbox)); - for (l = children; l; l = l->next) - { - GtkWidget *child = l->data; - - gtk_container_remove (GTK_CONTAINER (wrapbox), child); - } - g_list_free (children); - - if (items_type == SIMPLE_ITEMS) - populate_wrapbox_simple (wrapbox); - else if (items_type == WRAPPY_ITEMS) - populate_wrapbox_wrappy (wrapbox); - else if (items_type == STOCK_ITEMS) - populate_wrapbox_stock (wrapbox); -} - - -static void -mode_changed (GtkComboBox *box, - GtkWrapBox *wrapbox) -{ - GtkWrapAllocationMode mode = gtk_combo_box_get_active (box); - - gtk_wrap_box_set_allocation_mode (wrapbox, mode); -} - -static void -horizontal_spreading_changed (GtkComboBox *box, - GtkWrapBox *wrapbox) -{ - GtkWrapBoxSpreading spreading = gtk_combo_box_get_active (box); - - gtk_wrap_box_set_horizontal_spreading (wrapbox, spreading); -} - -static void -vertical_spreading_changed (GtkComboBox *box, - GtkWrapBox *wrapbox) -{ - GtkWrapBoxSpreading spreading = gtk_combo_box_get_active (box); - - gtk_wrap_box_set_vertical_spreading (wrapbox, spreading); -} - -static void -orientation_changed (GtkComboBox *box, - GtkWrapBox *wrapbox) -{ - GtkOrientation orientation = gtk_combo_box_get_active (box); - - gtk_orientable_set_orientation (GTK_ORIENTABLE (wrapbox), orientation); -} - -static void -line_length_changed (GtkSpinButton *spin, - GtkWrapBox *wrapbox) -{ - gint length = gtk_spin_button_get_value_as_int (spin); - - gtk_wrap_box_set_minimum_line_children (wrapbox, length); -} - -static void -spacing_changed (GtkSpinButton *button, - gpointer data) -{ - GtkOrientation orientation = GPOINTER_TO_INT (data); - gint state = gtk_spin_button_get_value_as_int (button); - - if (orientation == GTK_ORIENTATION_HORIZONTAL) - gtk_wrap_box_set_horizontal_spacing (the_wrapbox, state); - else - gtk_wrap_box_set_vertical_spacing (the_wrapbox, state); -} - - -static void -items_changed (GtkComboBox *box, - GtkWrapBox *wrapbox) -{ - items_type = gtk_combo_box_get_active (box); - - populate_items (wrapbox); -} - -static void -text_orientation_changed (GtkComboBox *box, - GtkWrapBox *wrapbox) -{ - text_orientation = gtk_combo_box_get_active (box); - - populate_items (wrapbox); -} - -static void -child_option_toggled (GtkToggleButton *button, - gboolean *state) -{ - *state = gtk_toggle_button_get_active (button); - - populate_items (the_wrapbox); -} - -static GtkWidget * -create_window (void) -{ - GtkWidget *window, *hbox, *vbox, *frame, *wrapbox_cntl, *items_cntl; - GtkWidget *wrapbox, *widget, *expander, *swindow; - - window = gtk_window_new (GTK_WINDOW_TOPLEVEL); - hbox = gtk_hbox_new (FALSE, 2); - vbox = gtk_vbox_new (FALSE, 6); - - gtk_container_set_border_width (GTK_CONTAINER (window), 8); - - gtk_widget_show (vbox); - gtk_widget_show (hbox); - gtk_container_add (GTK_CONTAINER (window), hbox); - gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); - - frame = gtk_frame_new ("Wrap Box"); - gtk_widget_show (frame); - gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); - - swindow = gtk_scrolled_window_new (NULL, NULL); - gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), - GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); - - gtk_widget_show (swindow); - gtk_container_add (GTK_CONTAINER (frame), swindow); - - wrapbox = gtk_wrap_box_new (INITIAL_ALLOCATION_MODE, INITIAL_SPREADING, - INITIAL_SPREADING, INITIAL_HSPACING, INITIAL_VSPACING); - the_wrapbox = (GtkWrapBox *)wrapbox; - gtk_wrap_box_set_minimum_line_children (GTK_WRAP_BOX (wrapbox), INITIAL_MINIMUM_LENGTH); - gtk_widget_show (wrapbox); - gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swindow), wrapbox); - - /* Add Wrapbox test control frame */ - expander = gtk_expander_new ("Wrap Box controls"); - gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE); - wrapbox_cntl = gtk_vbox_new (FALSE, 2); - gtk_widget_show (wrapbox_cntl); - gtk_widget_show (expander); - gtk_container_add (GTK_CONTAINER (expander), wrapbox_cntl); - gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0); - - /* Add Allocation mode control */ - widget = gtk_combo_box_new_text (); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Wrap Freely"); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Align items"); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Homogeneous"); - gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_ALLOCATION_MODE); - gtk_widget_show (widget); - - gtk_widget_set_tooltip_text (widget, "Set the wrapbox allocation mode"); - gtk_box_pack_start (GTK_BOX (wrapbox_cntl), widget, FALSE, FALSE, 0); - - g_signal_connect (G_OBJECT (widget), "changed", - G_CALLBACK (mode_changed), wrapbox); - - /* Add Spreading controls */ - widget = gtk_combo_box_new_text (); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Spread Start"); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Spread End"); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Spread Even"); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Spread Expand"); - gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_SPREADING); - gtk_widget_show (widget); - - gtk_widget_set_tooltip_text (widget, "Set the horizontal spreading mode"); - gtk_box_pack_start (GTK_BOX (wrapbox_cntl), widget, FALSE, FALSE, 0); - - g_signal_connect (G_OBJECT (widget), "changed", - G_CALLBACK (horizontal_spreading_changed), wrapbox); - - widget = gtk_combo_box_new_text (); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Spread Start"); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Spread End"); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Spread Even"); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Spread Expand"); - gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_SPREADING); - gtk_widget_show (widget); - - gtk_widget_set_tooltip_text (widget, "Set the vertical spreading mode"); - gtk_box_pack_start (GTK_BOX (wrapbox_cntl), widget, FALSE, FALSE, 0); - - g_signal_connect (G_OBJECT (widget), "changed", - G_CALLBACK (vertical_spreading_changed), wrapbox); - - /* Add Orientation control */ - widget = gtk_combo_box_new_text (); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Horizontal"); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Vertical"); - gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0); - gtk_widget_show (widget); - - gtk_widget_set_tooltip_text (widget, "Set the wrapbox orientation"); - gtk_box_pack_start (GTK_BOX (wrapbox_cntl), widget, FALSE, FALSE, 0); - - g_signal_connect (G_OBJECT (widget), "changed", - G_CALLBACK (orientation_changed), wrapbox); - - /* Add minimum line length in items control */ - widget = gtk_spin_button_new_with_range (1, 10, 1); - gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_MINIMUM_LENGTH); - gtk_widget_show (widget); - - gtk_widget_set_tooltip_text (widget, "Set the minimum amount of items per line before wrapping"); - gtk_box_pack_start (GTK_BOX (wrapbox_cntl), widget, FALSE, FALSE, 0); - - g_signal_connect (G_OBJECT (widget), "changed", - G_CALLBACK (line_length_changed), wrapbox); - g_signal_connect (G_OBJECT (widget), "value-changed", - G_CALLBACK (line_length_changed), wrapbox); - - /* Add horizontal/vertical spacing controls */ - hbox = gtk_hbox_new (FALSE, 2); - gtk_widget_show (hbox); - - widget = gtk_label_new ("H Spacing"); - gtk_widget_show (widget); - gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); - - widget = gtk_spin_button_new_with_range (0, 30, 1); - gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_HSPACING); - gtk_widget_show (widget); - - gtk_widget_set_tooltip_text (widget, "Set the horizontal spacing between children"); - gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0); - - g_signal_connect (G_OBJECT (widget), "changed", - G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL)); - g_signal_connect (G_OBJECT (widget), "value-changed", - G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL)); - - gtk_box_pack_start (GTK_BOX (wrapbox_cntl), hbox, FALSE, FALSE, 0); - - hbox = gtk_hbox_new (FALSE, 2); - gtk_widget_show (hbox); - - widget = gtk_label_new ("V Spacing"); - gtk_widget_show (widget); - gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); - - widget = gtk_spin_button_new_with_range (0, 30, 1); - gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_VSPACING); - gtk_widget_show (widget); - - gtk_widget_set_tooltip_text (widget, "Set the vertical spacing between children"); - gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0); - - g_signal_connect (G_OBJECT (widget), "changed", - G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL)); - g_signal_connect (G_OBJECT (widget), "value-changed", - G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL)); - - gtk_box_pack_start (GTK_BOX (wrapbox_cntl), hbox, FALSE, FALSE, 0); - - - /* Add test items control frame */ - expander = gtk_expander_new ("Test item controls"); - gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE); - items_cntl = gtk_vbox_new (FALSE, 2); - gtk_widget_show (items_cntl); - gtk_widget_show (expander); - gtk_container_add (GTK_CONTAINER (expander), items_cntl); - gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0); - - /* Add Items control */ - widget = gtk_combo_box_new_text (); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Simple"); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Wrappy"); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Stock"); - gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0); - gtk_widget_show (widget); - - gtk_widget_set_tooltip_text (widget, "Set the item set to use"); - gtk_box_pack_start (GTK_BOX (items_cntl), widget, FALSE, FALSE, 0); - - g_signal_connect (G_OBJECT (widget), "changed", - G_CALLBACK (items_changed), wrapbox); - - - /* Add Text Orientation control */ - widget = gtk_combo_box_new_text (); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Horizontal"); - gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Vertical"); - gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0); - gtk_widget_show (widget); - - gtk_widget_set_tooltip_text (widget, "Set the item's text orientation (cant be done for stock buttons)"); - gtk_box_pack_start (GTK_BOX (items_cntl), widget, FALSE, FALSE, 0); - - g_signal_connect (G_OBJECT (widget), "changed", - G_CALLBACK (text_orientation_changed), wrapbox); - - - /* Add expand options */ - hbox = gtk_hbox_new (FALSE, 2); - gtk_widget_show (hbox); - - widget = gtk_check_button_new_with_label ("X Expand"); - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE); - gtk_widget_show (widget); - - gtk_widget_set_tooltip_text (widget, "Set whether the items expand horizontally"); - gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0); - - g_signal_connect (G_OBJECT (widget), "toggled", - G_CALLBACK (child_option_toggled), &items_xexpand); - - - widget = gtk_check_button_new_with_label ("Y Expand"); - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE); - gtk_widget_show (widget); - - gtk_widget_set_tooltip_text (widget, "Set whether the items expand vertically"); - gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0); - - g_signal_connect (G_OBJECT (widget), "toggled", - G_CALLBACK (child_option_toggled), &items_yexpand); - - gtk_box_pack_start (GTK_BOX (items_cntl), hbox, FALSE, FALSE, 0); - - populate_items (GTK_WRAP_BOX (wrapbox)); - - /* This line was added only for the convenience of reproducing - * a height-for-width inside GtkScrolledWindow bug (bug 629778). - * -Tristan - */ - gtk_window_set_default_size (GTK_WINDOW (window), 390, -1); - - return window; -} - - - -int -main (int argc, char *argv[]) -{ - GtkWidget *window; - - gtk_init (&argc, &argv); - - window = create_window (); - - g_signal_connect (window, "delete-event", - G_CALLBACK (gtk_main_quit), window); - - gtk_widget_show (window); - - gtk_main (); - - return 0; -} -- 2.30.2